# encoding: UTF-8

"""
这里的Demo是一个最简单的策略实现，并未考虑太多实盘中的交易细节，如：
1. 委托价格超出涨跌停价导致的委托失败
2. 委托未成交，需要撤单后重新委托
3. 断网后恢复交易状态
4. 等等
这些点是作者选择特意忽略不去实现，因此想实盘的朋友请自己多多研究CTA交易的一些细节，
做到了然于胸后再去交易，对自己的money和时间负责。
也希望社区能做出一个解决了以上潜在风险的Demo出来。
"""

from ctpquant.ctaAlgo.ctaBase import *
from ctpquant.zw_talib import *
from ctpquant.indicators import *
from ctpquant.ctaAlgo.strategyTemplate import StrategyTemplate


########################################################################
class StrategyFractal(StrategyTemplate):
    """趋势策略"""
    className = 'StrategyFractal'
    author = 'Boxi'

    # 策略参数
    fastK = 0.75  # 快速EMA参数
    slowK = 0.25  # 慢速EMA参数
    initDays = 10  # 初始化数据所用的天数

    # 策略变量
    bar = None
    barMinute = EMPTY_STRING

    fastMa = []  # 快速EMA均线数组
    fastMa0 = EMPTY_FLOAT  # 当前最新的快速EMA
    fastMa1 = EMPTY_FLOAT  # 上一根的快速EMA

    slowMa = []  # 与上面相同
    slowMa0 = EMPTY_FLOAT
    slowMa1 = EMPTY_FLOAT

    # 参数列表，保存了参数的名称
    aramNameList = ['name',
                    'className',
                    'author',
                    'vtSymbol',
                    'symbol',
                    'openLongCondition',
                    'closeLongCondition',
                    'openShortCondition',
                    'closeShortCondition',
                    'trendClass',
                    'slipPoints',
                    'stopLossType',
                    'basePeriods',
                    'longTimes',
                    'shortTimes'
                    ]

    # 变量列表，保存了变量的名称
    varList = ['inited',
               'trading',
               'pos',
               'fastMa0',
               'fastMa1',
               'slowMa0',
               'slowMa1']

    def __init__(self, strategyEngine, setting):
        """Constructor"""
        # print(setting)
        super(StrategyFractal, self).__init__(strategyEngine, setting)

        # print('# 注意策略类中的可变对象属性（通常是list和dict等），在策略初始化时需要重新创建，')
        # 否则会出现多个策略实例之间数据共享的情况，有可能导致潜在的策略逻辑错误风险，
        # 策略类中的这些可变对象属性可以选择不写，全都放在__init__下面，写主要是为了阅读
        # 策略时方便（更多是个编程习惯的选择）
        # print('StrategyTrend __init__')
        self.fastMa = []
        self.slowMa = []
        self.fractalParams = {
            'UC8UC4': 0.1,
            'UC8ND3': 0.5,
            'UC8UC7': -0.5,
            'UC7UC8': -0.3,
            'UC7ND2': 0.0,
            'UC4UC8': -0.5,
            'UC4ND2': -0.3,
            'NU3UC4': -0.5,
            'NU3UC7': -0.3,
            'NU3ND3': -0.4,
            'NU2UC8': -0.5,
            'NU2ND2': 0.05,
            'ND2NU2': 0.5,
            'ND2DC8': 0.5,
            'ND3NU3': 0.05,
            'ND3DC4': 0.0,
            'ND3DC7': 0.0,
            'DC4DC8': 0.5,
            'DC4NU2': 0.5,
            'DC7DC8': 0.5,
            'DC7NU2': 0.001,
            'DC8DC4': -0.4,
            'DC8NU3': -0.01,
            'DC8DC7': 0.5
        }

    def onInit(self):
        # print("""初始化策略（必须由用户继承实现）""")
        self.writeCtaLog('趋势策略初始化')

        self.bars = self.loadBar(self.initDays)
        # self.onBars(self.bars)
        for bar in self.bars:
            self.onBar(bar)

        self.putEvent()

    def onStart(self):
        """启动策略（必须由用户继承实现）"""
        self.writeCtaLog('趋势策略启动')
        self.putEvent()

    def onStop(self):
        """停止策略（必须由用户继承实现）"""
        self.writeCtaLog('趋势策略停止')
        self.putEvent()

    def onTick(self, tick):
        """收到行情TICK推送（必须由用户继承实现）"""
        # 计算K线
        tickMinute = tick.datetime.minute

        if tickMinute != self.barMinute:
            if self.bar:
                self.onBar(self.bar)

            bar = CtaBarData()
            bar.vtSymbol = tick.vtSymbol
            bar.symbol = tick.symbol
            bar.exchange = tick.exchange

            bar.open = tick.lastPrice
            bar.high = tick.lastPrice
            bar.low = tick.lastPrice
            bar.close = tick.lastPrice

            bar.date = tick.date
            bar.time = tick.time
            bar.datetime = tick.datetime  # K线的时间设为第一个Tick的时间

            # 实盘中用不到的数据可以选择不算，从而加快速度
            # bar.volume = tick.volume
            # bar.openInterest = tick.openInterest

            self.bar = bar  # 这种写法为了减少一层访问，加快速度
            self.barMinute = tickMinute  # 更新当前的分钟

        else:  # 否则继续累加新的K线
            bar = self.bar  # 写法同样为了加快速度

            bar.high = max(bar.high, tick.lastPrice)
            bar.low = min(bar.low, tick.lastPrice)
            bar.close = tick.lastPrice

    # --------------根据每一K线，计算相关指标--------------------------
    def onBar(self, bar):
        """收到Bar推送（必须由用户继承实现）"""
        # 计算快慢均线
        # print(bar)
        if not self.fastMa0:
            self.fastMa0 = bar.close
            self.fastMa.append(self.fastMa0)
        else:
            self.fastMa1 = self.fastMa0
            self.fastMa0 = bar.close * self.fastK + self.fastMa0 * (1 - self.fastK)
            self.fastMa.append(self.fastMa0)

        if not self.slowMa0:
            self.slowMa0 = bar.close
            self.slowMa.append(self.slowMa0)
        else:
            self.slowMa1 = self.slowMa0
            self.slowMa0 = bar.close * self.slowK + self.slowMa0 * (1 - self.slowK)
            self.slowMa.append(self.slowMa0)

        # 判断买卖
        crossOver = self.fastMa0 > self.slowMa0 and self.fastMa1 < self.slowMa1  # 金叉上穿
        crossBelow = self.fastMa0 < self.slowMa0 and self.fastMa1 > self.slowMa1  # 死叉下穿
        # print('crossover={}'.format(crossOver),'crossBelow={}'.format(crossBelow))
        # 金叉和死叉的条件是互斥
        # 所有的委托均以K线收盘价委托（这里有一个实盘中无法成交的风险，考虑添加对模拟市价单类型的支持）
        if crossOver:
            # 如果金叉时手头没有持仓，则直接做多
            if self.pos == 0:
                self.buy(bar.close, 1)
            # 如果有空头持仓，则先平空，再做多
            elif self.pos < 0:
                self.cover(bar.close, 1)
                self.buy(bar.close, 1)
        # 死叉和金叉相反
        elif crossBelow:
            # print(self.pos)
            if self.pos == 0:
                self.short(bar.close, 1)
            elif self.pos > 0:
                self.sell(bar.close, 1)
                self.short(bar.close, 1)

        # 发出状态更新事件
        self.putEvent()

    def onBars(self, bars):
        '''收到历史Bars推送（必须由用户继承实现）
        计算所有用到的指标
        '''
        self.fractal = Fractal(bars['datetime'], bars['high'], bars['low'], self.params['fractalClass'].default)
        self.hhh = HHV(bars, self.pHH, ksgn='high')['hhh']
        self.lll = LLV(bars, self.pLL, ksgn='low')['lll']
        self.dma = DMA(bars, self.pDMA, ksgn='close')['dma']

    def onOrder(self, order):
        """收到委托变化推送（必须由用户继承实现）"""
        # 对于无需做细粒度委托控制的策略，可以忽略onOrder
        pass

    def onTrade(self, trade):
        """收到成交推送（必须由用户继承实现）"""
        # 对于无需做细粒度委托控制的策略，可以忽略onOrder
        pass

